if (typeof Promise !== "undefined" && !Promise.prototype.finally) {
  Promise.prototype.finally = function(callback) {
    const promise = this.constructor;
    return this.then(
      (value) => promise.resolve(callback()).then(() => value),
      (reason) => promise.resolve(callback()).then(() => {
        throw reason;
      })
    );
  };
}
;
if (typeof uni !== "undefined" && uni && uni.requireGlobal) {
  const global = uni.requireGlobal();
  ArrayBuffer = global.ArrayBuffer;
  Int8Array = global.Int8Array;
  Uint8Array = global.Uint8Array;
  Uint8ClampedArray = global.Uint8ClampedArray;
  Int16Array = global.Int16Array;
  Uint16Array = global.Uint16Array;
  Int32Array = global.Int32Array;
  Uint32Array = global.Uint32Array;
  Float32Array = global.Float32Array;
  Float64Array = global.Float64Array;
  BigInt64Array = global.BigInt64Array;
  BigUint64Array = global.BigUint64Array;
}
;
if (uni.restoreGlobal) {
  uni.restoreGlobal(Vue, weex, plus, setTimeout, clearTimeout, setInterval, clearInterval);
}
(function(vue) {
  "use strict";
  function initRuntimeSocket(hosts, port, id) {
    if (hosts == "" || port == "" || id == "")
      return Promise.resolve(null);
    return hosts.split(",").reduce((promise, host) => {
      return promise.then((socket) => {
        if (socket != null)
          return Promise.resolve(socket);
        return tryConnectSocket(host, port, id);
      });
    }, Promise.resolve(null));
  }
  const SOCKET_TIMEOUT = 500;
  function tryConnectSocket(host, port, id) {
    return new Promise((resolve, reject) => {
      const socket = uni.connectSocket({
        url: `ws://${host}:${port}/${id}`,
        multiple: true,
        // 支付宝小程序 是否开启多实例
        fail() {
          resolve(null);
        }
      });
      const timer = setTimeout(() => {
        socket.close({
          code: 1006,
          reason: "connect timeout"
        });
        resolve(null);
      }, SOCKET_TIMEOUT);
      socket.onOpen((e) => {
        clearTimeout(timer);
        resolve(socket);
      });
      socket.onClose((e) => {
        clearTimeout(timer);
        resolve(null);
      });
      socket.onError((e) => {
        clearTimeout(timer);
        resolve(null);
      });
    });
  }
  function formatMessage(type, args) {
    try {
      return {
        type,
        args: formatArgs(args)
      };
    } catch (e) {
    }
    return {
      type,
      args: []
    };
  }
  function formatArgs(args) {
    return args.map((arg) => formatArg(arg));
  }
  function formatArg(arg, depth = 0) {
    if (depth >= 7) {
      return {
        type: "object",
        value: "[Maximum depth reached]"
      };
    }
    const type = typeof arg;
    switch (type) {
      case "string":
        return formatString(arg);
      case "number":
        return formatNumber(arg);
      case "boolean":
        return formatBoolean(arg);
      case "object":
        return formatObject(arg, depth);
      case "undefined":
        return formatUndefined();
      case "function":
        return formatFunction(arg);
      case "symbol": {
        return formatSymbol(arg);
      }
      case "bigint":
        return formatBigInt(arg);
    }
  }
  function formatFunction(value) {
    return {
      type: "function",
      value: `function ${value.name}() {}`
    };
  }
  function formatUndefined() {
    return {
      type: "undefined"
    };
  }
  function formatBoolean(value) {
    return {
      type: "boolean",
      value: String(value)
    };
  }
  function formatNumber(value) {
    return {
      type: "number",
      value: String(value)
    };
  }
  function formatBigInt(value) {
    return {
      type: "bigint",
      value: String(value)
    };
  }
  function formatString(value) {
    return {
      type: "string",
      value
    };
  }
  function formatSymbol(value) {
    return {
      type: "symbol",
      value: value.description
    };
  }
  function formatObject(value, depth) {
    if (value === null) {
      return {
        type: "null"
      };
    }
    {
      if (isComponentPublicInstance(value)) {
        return formatComponentPublicInstance(value, depth);
      }
      if (isComponentInternalInstance(value)) {
        return formatComponentInternalInstance(value, depth);
      }
      if (isUniElement(value)) {
        return formatUniElement(value, depth);
      }
      if (isCSSStyleDeclaration(value)) {
        return formatCSSStyleDeclaration(value, depth);
      }
    }
    if (Array.isArray(value)) {
      return {
        type: "object",
        subType: "array",
        value: {
          properties: value.map((v, i) => formatArrayElement(v, i, depth + 1))
        }
      };
    }
    if (value instanceof Set) {
      return {
        type: "object",
        subType: "set",
        className: "Set",
        description: `Set(${value.size})`,
        value: {
          entries: Array.from(value).map((v) => formatSetEntry(v, depth + 1))
        }
      };
    }
    if (value instanceof Map) {
      return {
        type: "object",
        subType: "map",
        className: "Map",
        description: `Map(${value.size})`,
        value: {
          entries: Array.from(value.entries()).map((v) => formatMapEntry(v, depth + 1))
        }
      };
    }
    if (value instanceof Promise) {
      return {
        type: "object",
        subType: "promise",
        value: {
          properties: []
        }
      };
    }
    if (value instanceof RegExp) {
      return {
        type: "object",
        subType: "regexp",
        value: String(value),
        className: "Regexp"
      };
    }
    if (value instanceof Date) {
      return {
        type: "object",
        subType: "date",
        value: String(value),
        className: "Date"
      };
    }
    if (value instanceof Error) {
      return {
        type: "object",
        subType: "error",
        value: value.message || String(value),
        className: value.name || "Error"
      };
    }
    let className = void 0;
    {
      const constructor = value.constructor;
      if (constructor) {
        if (constructor.get$UTSMetadata$) {
          className = constructor.get$UTSMetadata$().name;
        }
      }
    }
    return {
      type: "object",
      className,
      value: {
        properties: Object.entries(value).map((entry) => formatObjectProperty(entry[0], entry[1], depth + 1))
      }
    };
  }
  function isComponentPublicInstance(value) {
    return value.$ && isComponentInternalInstance(value.$);
  }
  function isComponentInternalInstance(value) {
    return value.type && value.uid != null && value.appContext;
  }
  function formatComponentPublicInstance(value, depth) {
    return {
      type: "object",
      className: "ComponentPublicInstance",
      value: {
        properties: Object.entries(value.$.type).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function formatComponentInternalInstance(value, depth) {
    return {
      type: "object",
      className: "ComponentInternalInstance",
      value: {
        properties: Object.entries(value.type).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function isUniElement(value) {
    return value.style && value.tagName != null && value.nodeName != null;
  }
  function formatUniElement(value, depth) {
    return {
      type: "object",
      // 非 x 没有 UniElement 的概念
      // className: 'UniElement',
      value: {
        properties: Object.entries(value).filter(([name]) => [
          "id",
          "tagName",
          "nodeName",
          "dataset",
          "offsetTop",
          "offsetLeft",
          "style"
        ].includes(name)).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function isCSSStyleDeclaration(value) {
    return typeof value.getPropertyValue === "function" && typeof value.setProperty === "function" && value.$styles;
  }
  function formatCSSStyleDeclaration(style, depth) {
    return {
      type: "object",
      value: {
        properties: Object.entries(style.$styles).map(([name, value]) => formatObjectProperty(name, value, depth + 1))
      }
    };
  }
  function formatObjectProperty(name, value, depth) {
    const result = formatArg(value, depth);
    result.name = name;
    return result;
  }
  function formatArrayElement(value, index, depth) {
    const result = formatArg(value, depth);
    result.name = `${index}`;
    return result;
  }
  function formatSetEntry(value, depth) {
    return {
      value: formatArg(value, depth)
    };
  }
  function formatMapEntry(value, depth) {
    return {
      key: formatArg(value[0], depth),
      value: formatArg(value[1], depth)
    };
  }
  const CONSOLE_TYPES = ["log", "warn", "error", "info", "debug"];
  let sendConsole = null;
  const messageQueue = [];
  const messageExtra = {};
  function sendConsoleMessages(messages) {
    if (sendConsole == null) {
      messageQueue.push(...messages);
      return;
    }
    sendConsole(JSON.stringify(Object.assign({
      type: "console",
      data: messages
    }, messageExtra)));
  }
  function setSendConsole(value, extra = {}) {
    sendConsole = value;
    Object.assign(messageExtra, extra);
    if (value != null && messageQueue.length > 0) {
      const messages = messageQueue.slice();
      messageQueue.length = 0;
      sendConsoleMessages(messages);
    }
  }
  const originalConsole = /* @__PURE__ */ CONSOLE_TYPES.reduce((methods, type) => {
    methods[type] = console[type].bind(console);
    return methods;
  }, {});
  function rewriteConsole() {
    function wrapConsole(type) {
      return function(...args) {
        [...args];
        sendConsoleMessages([formatMessage(type, args)]);
      };
    }
    if (isConsoleWritable()) {
      CONSOLE_TYPES.forEach((type) => {
        console[type] = wrapConsole(type);
      });
      return function restoreConsole() {
        CONSOLE_TYPES.forEach((type) => {
          console[type] = originalConsole[type];
        });
      };
    } else {
      {
        if (typeof uni !== "undefined" && uni.__f__) {
          const oldLog = uni.__f__;
          if (oldLog) {
            uni.__f__ = function(...args) {
              const [type, filename, ...rest] = args;
              oldLog(type, "", ...rest);
              sendConsoleMessages([formatMessage(type, [...rest, filename])]);
            };
            return function restoreConsole() {
              uni.__f__ = oldLog;
            };
          }
        }
      }
    }
    return function restoreConsole() {
    };
  }
  function isConsoleWritable() {
    const value = console.log;
    const sym = Symbol();
    try {
      console.log = sym;
    } catch (ex) {
      return false;
    }
    const isWritable = console.log === sym;
    console.log = value;
    return isWritable;
  }
  let sendError = null;
  const errorQueue = /* @__PURE__ */ new Set();
  const errorExtra = {};
  function sendErrorMessages(errors) {
    if (sendError == null) {
      errors.forEach((error) => {
        errorQueue.add(error);
      });
      return;
    }
    const data = errors.map((err) => {
      const isPromiseRejection = err && "promise" in err && "reason" in err;
      const prefix = isPromiseRejection ? "UnhandledPromiseRejection: " : "";
      if (isPromiseRejection) {
        err = err.reason;
      }
      if (err instanceof Error && err.stack) {
        if (err.message && !err.stack.includes(err.message)) {
          return `${prefix}${err.message}
${err.stack}`;
        }
        return `${prefix}${err.stack}`;
      }
      if (typeof err === "object" && err !== null) {
        try {
          return prefix + JSON.stringify(err);
        } catch (err2) {
          return prefix + String(err2);
        }
      }
      return prefix + String(err);
    }).filter(Boolean);
    if (data.length > 0) {
      sendError(JSON.stringify(Object.assign({
        type: "error",
        data
      }, errorExtra)));
    }
  }
  function setSendError(value, extra = {}) {
    sendError = value;
    Object.assign(errorExtra, extra);
    if (value != null && errorQueue.size > 0) {
      const errors = Array.from(errorQueue);
      errorQueue.clear();
      sendErrorMessages(errors);
    }
  }
  function initOnError() {
    function onError(error) {
      try {
        if (typeof PromiseRejectionEvent !== "undefined" && error instanceof PromiseRejectionEvent && error.reason instanceof Error && error.reason.message && error.reason.message.includes(`Cannot create property 'errMsg' on string 'taskId`)) {
          return;
        }
        if (false)
          ;
        sendErrorMessages([error]);
      } catch (err) {
        originalConsole.error(err);
      }
    }
    if (typeof uni.onError === "function") {
      uni.onError(onError);
    }
    if (typeof uni.onUnhandledRejection === "function") {
      uni.onUnhandledRejection(onError);
    }
    return function offError() {
      if (typeof uni.offError === "function") {
        uni.offError(onError);
      }
      if (typeof uni.offUnhandledRejection === "function") {
        uni.offUnhandledRejection(onError);
      }
    };
  }
  function initRuntimeSocketService() {
    const hosts = "127.0.0.1,192.168.31.50";
    const port = "8090";
    const id = "app-harmony_-s88ET";
    const lazy = typeof swan !== "undefined";
    let restoreError = lazy ? () => {
    } : initOnError();
    let restoreConsole = lazy ? () => {
    } : rewriteConsole();
    return Promise.resolve().then(() => {
      if (lazy) {
        restoreError = initOnError();
        restoreConsole = rewriteConsole();
      }
      return initRuntimeSocket(hosts, port, id).then((socket) => {
        if (!socket) {
          restoreError();
          restoreConsole();
          originalConsole.error(wrapError("开发模式下日志通道建立 socket 连接失败。"));
          originalConsole.error(wrapError("如果是小程序平台，请勾选不校验合法域名配置。"));
          originalConsole.error(wrapError("如果是运行到真机，请确认手机与电脑处于同一网络。"));
          return false;
        }
        initMiniProgramGlobalFlag();
        socket.onClose(() => {
          originalConsole.error(wrapError("开发模式下日志通道 socket 连接关闭，请在 HBuilderX 中重新运行。"));
          restoreError();
          restoreConsole();
        });
        setSendConsole((data) => {
          socket.send({
            data
          });
        });
        setSendError((data) => {
          socket.send({
            data
          });
        });
        return true;
      });
    });
  }
  const ERROR_CHAR = "‌";
  function wrapError(error) {
    return `${ERROR_CHAR}${error}${ERROR_CHAR}`;
  }
  function initMiniProgramGlobalFlag() {
    if (typeof wx !== "undefined") {
      wx.__uni_console__ = true;
    } else if (typeof my !== "undefined") {
      my.__uni_console__ = true;
    } else if (typeof tt !== "undefined") {
      tt.__uni_console__ = true;
    } else if (typeof swan !== "undefined") {
      swan.__uni_console__ = true;
    } else if (typeof qq !== "undefined") {
      qq.__uni_console__ = true;
    } else if (typeof ks !== "undefined") {
      ks.__uni_console__ = true;
    } else if (typeof jd !== "undefined") {
      jd.__uni_console__ = true;
    } else if (typeof xhs !== "undefined") {
      xhs.__uni_console__ = true;
    } else if (typeof has !== "undefined") {
      has.__uni_console__ = true;
    } else if (typeof qa !== "undefined") {
      qa.__uni_console__ = true;
    }
  }
  initRuntimeSocketService();
  const _export_sfc = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key, val] of props) {
      target[key] = val;
    }
    return target;
  };
  const _sfc_main$2 = {
    data() {
      return {
        fortuneTypes: [
          {
            title: "塔罗牌",
            description: "揭示你的命运轨迹",
            icon: "/static/tarot.png",
            type: "tarot"
          },
          {
            title: "星座运势",
            description: "了解今日星座运程",
            icon: "/static/zodiac.png",
            type: "zodiac"
          },
          {
            title: "姓名测算",
            description: "解读姓名中的天机",
            icon: "/static/name.png",
            type: "name"
          },
          {
            title: "周公解梦",
            description: "揭秘梦境的玄机",
            icon: "/static/dream.png",
            type: "dream"
          }
        ]
      };
    },
    methods: {
      startFortune(item) {
        uni.navigateTo({
          url: `/pages/fortune/fortune?type=${item.type}`
        });
      },
      openDeveloperSite() {
        plus.runtime.openURL("https://www.nutpi.net/");
      }
    }
  };
  function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("view", { class: "content" }, [
      vue.createElementVNode("view", { class: "header" }, [
        vue.createElementVNode("text", { class: "title" }, "神秘占卜屋"),
        vue.createElementVNode("text", { class: "subtitle" }, "揭开命运的神秘面纱")
      ]),
      vue.createElementVNode("view", { class: "fortune-cards" }, [
        (vue.openBlock(true), vue.createElementBlock(
          vue.Fragment,
          null,
          vue.renderList($data.fortuneTypes, (item, index) => {
            return vue.openBlock(), vue.createElementBlock("view", {
              class: "card",
              key: index,
              onClick: ($event) => $options.startFortune(item)
            }, [
              vue.createElementVNode("image", {
                src: item.icon,
                class: "card-icon"
              }, null, 8, ["src"]),
              vue.createElementVNode(
                "text",
                { class: "card-title" },
                vue.toDisplayString(item.title),
                1
                /* TEXT */
              ),
              vue.createElementVNode(
                "text",
                { class: "card-desc" },
                vue.toDisplayString(item.description),
                1
                /* TEXT */
              )
            ], 8, ["onClick"]);
          }),
          128
          /* KEYED_FRAGMENT */
        ))
      ]),
      vue.createElementVNode("view", { class: "developer-info" }, [
        vue.createElementVNode("text", null, "开发者："),
        vue.createElementVNode("text", {
          class: "developer-link",
          onClick: _cache[0] || (_cache[0] = (...args) => $options.openDeveloperSite && $options.openDeveloperSite(...args))
        }, "坚果")
      ])
    ]);
  }
  const PagesIndexIndex = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$1], ["__file", "/Users/jianguo/Desktop/teaching/zhanbu/pages/index/index.vue"]]);
  const _imports_0 = "/static/card-back.png";
  const _sfc_main$1 = {
    data() {
      return {
        type: "",
        showResult: false,
        fortuneInfo: {},
        // 塔罗牌
        tarotCards: new Array(22).fill({}),
        selectedCards: [],
        selectedCardsInfo: [],
        // 星座
        zodiacSigns: [
          "白羊座",
          "金牛座",
          "双子座",
          "巨蟹座",
          "狮子座",
          "处女座",
          "天秤座",
          "天蝎座",
          "射手座",
          "摩羯座",
          "水瓶座",
          "双鱼座"
        ],
        zodiacIndex: 0,
        zodiacResult: null,
        // 姓名
        userName: "",
        nameResult: null,
        // 解梦
        dreamContent: "",
        dreamResult: null
      };
    },
    onLoad(option) {
      this.type = option.type;
      this.setFortuneInfo();
    },
    methods: {
      setFortuneInfo() {
        const typeMap = {
          tarot: {
            title: "塔罗牌占卜",
            description: "请选择三张牌，让塔罗牌为您揭示命运的指引"
          },
          zodiac: {
            title: "星座运势",
            description: "选择您的星座，查看今日运势"
          },
          name: {
            title: "姓名测算",
            description: "解读您姓名中蕴含的天机"
          },
          dream: {
            title: "周公解梦",
            description: "揭示梦境背后的玄机"
          }
        };
        this.fortuneInfo = typeMap[this.type];
      },
      // 塔罗牌方法
      selectCard(index) {
        if (this.selectedCards.length >= 3 || this.selectedCards.includes(index))
          return;
        this.selectedCards.push(index);
      },
      // 星座方法
      onZodiacChange(e) {
        this.zodiacIndex = e.detail.value;
      },
      // 开始占卜
      startDivination() {
        switch (this.type) {
          case "tarot":
            if (this.selectedCards.length !== 3) {
              uni.showToast({ title: "请选择三张塔罗牌", icon: "none" });
              return;
            }
            this.getTarotResult();
            break;
          case "zodiac":
            this.getZodiacResult();
            break;
          case "name":
            if (!this.userName) {
              uni.showToast({ title: "请输入姓名", icon: "none" });
              return;
            }
            this.getNameResult();
            break;
          case "dream":
            if (!this.dreamContent) {
              uni.showToast({ title: "请描述您的梦境", icon: "none" });
              return;
            }
            this.getDreamResult();
            break;
        }
        this.showResult = true;
      },
      // 重置占卜
      resetDivination() {
        this.showResult = false;
        this.selectedCards = [];
        this.selectedCardsInfo = [];
        this.zodiacResult = null;
        this.nameResult = null;
        this.dreamResult = null;
      },
      // 获取占卜结果
      getTarotResult() {
        const tarotDatabase = [
          { name: "命运之轮", meaning: "机会来临，命运的转折点" },
          { name: "星星", meaning: "希望与信心，光明就在前方" },
          { name: "太阳", meaning: "幸福与成功，充满活力" },
          { name: "月亮", meaning: "直觉与潜意识，内心的指引" },
          { name: "正义", meaning: "公平与平衡，理性的决定" }
        ];
        this.selectedCardsInfo = this.selectedCards.map(() => {
          return tarotDatabase[Math.floor(Math.random() * tarotDatabase.length)];
        });
      },
      getZodiacResult() {
        this.zodiacResult = {
          "整体运势": "今日运势不错，适合尝试新事物",
          "爱情运势": "单身的人可能会遇到心仪的对象",
          "事业运势": "工作中会有新的机遇，保持积极态度",
          "财运": "财运稳定，适合理财投资"
        };
      },
      getNameResult() {
        this.nameResult = [
          { label: "性格特点", value: "善良开朗，富有同情心" },
          { label: "事业发展", value: "适合从事创造性工作" },
          { label: "人际关系", value: "人缘较好，容易获得他人信任" },
          { label: "财运分析", value: "财运良好，注意稳健理财" }
        ];
      },
      getDreamResult() {
        this.dreamResult = "您的梦境暗示着内心的渴望和期待，建议保持乐观积极的心态，好运即将来临。";
      }
    }
  };
  function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("view", { class: "container" }, [
      vue.createElementVNode("view", { class: "fortune-header" }, [
        vue.createElementVNode(
          "text",
          { class: "fortune-title" },
          vue.toDisplayString($data.fortuneInfo.title),
          1
          /* TEXT */
        ),
        vue.createElementVNode(
          "text",
          { class: "fortune-desc" },
          vue.toDisplayString($data.fortuneInfo.description),
          1
          /* TEXT */
        )
      ]),
      vue.createCommentVNode(" 塔罗牌占卜 "),
      $data.type === "tarot" ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 0,
        class: "tarot-section"
      }, [
        !$data.showResult ? (vue.openBlock(), vue.createElementBlock("view", {
          key: 0,
          class: "cards-container"
        }, [
          (vue.openBlock(true), vue.createElementBlock(
            vue.Fragment,
            null,
            vue.renderList($data.tarotCards, (card, index) => {
              return vue.openBlock(), vue.createElementBlock("view", {
                class: vue.normalizeClass(["card", { selected: $data.selectedCards.includes(index) }]),
                key: index,
                onClick: ($event) => $options.selectCard(index)
              }, [
                vue.createElementVNode("image", {
                  src: _imports_0,
                  class: "card-image"
                })
              ], 10, ["onClick"]);
            }),
            128
            /* KEYED_FRAGMENT */
          ))
        ])) : (vue.openBlock(), vue.createElementBlock("view", {
          key: 1,
          class: "result-section"
        }, [
          (vue.openBlock(true), vue.createElementBlock(
            vue.Fragment,
            null,
            vue.renderList($data.selectedCardsInfo, (card, index) => {
              return vue.openBlock(), vue.createElementBlock("view", {
                class: "result-card",
                key: index
              }, [
                vue.createElementVNode("image", {
                  src: card.image,
                  class: "result-card-image"
                }, null, 8, ["src"]),
                vue.createElementVNode(
                  "text",
                  { class: "card-name" },
                  vue.toDisplayString(card.name),
                  1
                  /* TEXT */
                ),
                vue.createElementVNode(
                  "text",
                  { class: "card-meaning" },
                  vue.toDisplayString(card.meaning),
                  1
                  /* TEXT */
                )
              ]);
            }),
            128
            /* KEYED_FRAGMENT */
          ))
        ]))
      ])) : vue.createCommentVNode("v-if", true),
      vue.createCommentVNode(" 星座运势 "),
      $data.type === "zodiac" ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 1,
        class: "zodiac-section"
      }, [
        vue.createElementVNode("picker", {
          onChange: _cache[0] || (_cache[0] = (...args) => $options.onZodiacChange && $options.onZodiacChange(...args)),
          value: $data.zodiacIndex,
          range: $data.zodiacSigns
        }, [
          vue.createElementVNode("view", { class: "picker" }, [
            vue.createElementVNode(
              "text",
              null,
              "选择星座: " + vue.toDisplayString($data.zodiacSigns[$data.zodiacIndex]),
              1
              /* TEXT */
            )
          ])
        ], 40, ["value", "range"]),
        $data.zodiacResult ? (vue.openBlock(), vue.createElementBlock("view", {
          key: 0,
          class: "fortune-result"
        }, [
          (vue.openBlock(true), vue.createElementBlock(
            vue.Fragment,
            null,
            vue.renderList($data.zodiacResult, (item, key) => {
              return vue.openBlock(), vue.createElementBlock("view", {
                class: "fortune-item",
                key
              }, [
                vue.createElementVNode(
                  "text",
                  { class: "item-title" },
                  vue.toDisplayString(key),
                  1
                  /* TEXT */
                ),
                vue.createElementVNode(
                  "text",
                  { class: "item-content" },
                  vue.toDisplayString(item),
                  1
                  /* TEXT */
                )
              ]);
            }),
            128
            /* KEYED_FRAGMENT */
          ))
        ])) : vue.createCommentVNode("v-if", true)
      ])) : vue.createCommentVNode("v-if", true),
      vue.createCommentVNode(" 姓名测算 "),
      $data.type === "name" ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 2,
        class: "name-section"
      }, [
        vue.withDirectives(vue.createElementVNode(
          "input",
          {
            type: "text",
            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => $data.userName = $event),
            placeholder: "请输入您的姓名",
            class: "name-input"
          },
          null,
          512
          /* NEED_PATCH */
        ), [
          [vue.vModelText, $data.userName]
        ]),
        $data.nameResult ? (vue.openBlock(), vue.createElementBlock("view", {
          key: 0,
          class: "name-result"
        }, [
          (vue.openBlock(true), vue.createElementBlock(
            vue.Fragment,
            null,
            vue.renderList($data.nameResult, (item, index) => {
              return vue.openBlock(), vue.createElementBlock("view", {
                class: "result-item",
                key: index
              }, [
                vue.createElementVNode(
                  "text",
                  { class: "item-label" },
                  vue.toDisplayString(item.label),
                  1
                  /* TEXT */
                ),
                vue.createElementVNode(
                  "text",
                  { class: "item-value" },
                  vue.toDisplayString(item.value),
                  1
                  /* TEXT */
                )
              ]);
            }),
            128
            /* KEYED_FRAGMENT */
          ))
        ])) : vue.createCommentVNode("v-if", true)
      ])) : vue.createCommentVNode("v-if", true),
      vue.createCommentVNode(" 周公解梦 "),
      $data.type === "dream" ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 3,
        class: "dream-section"
      }, [
        vue.withDirectives(vue.createElementVNode(
          "textarea",
          {
            "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => $data.dreamContent = $event),
            placeholder: "请描述您的梦境",
            class: "dream-input"
          },
          null,
          512
          /* NEED_PATCH */
        ), [
          [vue.vModelText, $data.dreamContent]
        ]),
        $data.dreamResult ? (vue.openBlock(), vue.createElementBlock("view", {
          key: 0,
          class: "dream-result"
        }, [
          vue.createElementVNode(
            "text",
            { class: "dream-interpretation" },
            vue.toDisplayString($data.dreamResult),
            1
            /* TEXT */
          )
        ])) : vue.createCommentVNode("v-if", true)
      ])) : vue.createCommentVNode("v-if", true),
      !$data.showResult ? (vue.openBlock(), vue.createElementBlock("button", {
        key: 4,
        class: "start-btn",
        onClick: _cache[3] || (_cache[3] = (...args) => $options.startDivination && $options.startDivination(...args))
      }, "开始占卜")) : (vue.openBlock(), vue.createElementBlock("button", {
        key: 5,
        class: "reset-btn",
        onClick: _cache[4] || (_cache[4] = (...args) => $options.resetDivination && $options.resetDivination(...args))
      }, "重新占卜"))
    ]);
  }
  const PagesFortuneFortune = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "/Users/jianguo/Desktop/teaching/zhanbu/pages/fortune/fortune.vue"]]);
  __definePage("pages/index/index", PagesIndexIndex);
  __definePage("pages/fortune/fortune", PagesFortuneFortune);
  function formatAppLog(type, filename, ...args) {
    if (uni.__log__) {
      uni.__log__(type, filename, ...args);
    } else {
      console[type].apply(console, [...args, filename]);
    }
  }
  const _sfc_main = {
    onLaunch: function() {
      formatAppLog("log", "at App.vue:4", "App Launch");
    },
    onShow: function() {
      formatAppLog("log", "at App.vue:7", "App Show");
    },
    onHide: function() {
      formatAppLog("log", "at App.vue:10", "App Hide");
    }
  };
  const App = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/Users/jianguo/Desktop/teaching/zhanbu/App.vue"]]);
  function createApp() {
    const app = vue.createVueApp(App);
    return {
      app
    };
  }
  const { app: __app__, Vuex: __Vuex__, Pinia: __Pinia__ } = createApp();
  uni.Vuex = __Vuex__;
  uni.Pinia = __Pinia__;
  __app__.provide("__globalStyles", __uniConfig.styles);
  __app__._component.mpType = "app";
  __app__._component.render = () => {
  };
  __app__.mount("#app");
})(Vue);
